home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / modelers / geomview / source.lha / Geomview / src / lib / mg / rib / mgribdraw.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-11-06  |  15.4 KB  |  577 lines
  1. #include "mgP.h"
  2. #include "mgribP.h"
  3. #include "mgribtoken.h"
  4. #include "polylistP.h"
  5.  
  6. #define MAXCLINE 999999
  7. void mgrib_drawPline(HPoint3 *p1, HPoint3 *p2);
  8. void mgrib_drawCline(HPoint3 *p1, HPoint3 *p2);
  9.  
  10. void    mgrib_polygon( int nv, HPoint3 *v, int nn, Point3 *n,
  11.                         int nc,ColorA *c );
  12. void    mgrib_mesh( int wrap,int nu,int nv,HPoint3 *p, Point3 *n,ColorA *c );
  13. void    mgrib_line( HPoint3 *p1, HPoint3 *p2 );
  14. void    mgrib_polyline( int nv, HPoint3 *verts, int nc, ColorA *colors,
  15.                 int wrapped );
  16. void    mgrib_polylist(  int np, Poly *p, int nv, Vertex *v, 
  17.                  int plflags );
  18. void    mgrib_drawnormal(HPoint3 *p, Point3 *n);
  19.                  
  20.  
  21.  
  22. /*-----------------------------------------------------------------------
  23.  * Function:    mgrib_polygon
  24.  * Description:    draw a polygon
  25.  * Author:    wisdom
  26.  * Date:    Thu Aug 26 13:46:25 CDT 1993
  27.  * Notes:    See mg.doc.
  28.  *
  29.  */
  30. void
  31. mgrib_polygon(int nv,  HPoint3 *V, 
  32.          int nn,  Point3 *N, 
  33.          int nc,  ColorA *C)
  34. {
  35.   register int i;    
  36.   register HPoint3 *v;
  37.   register Point3 *n;
  38.   register Color *c;
  39.   register ColorA *c4;
  40.   HPoint3 hpt;
  41.   int flag;
  42.   int shading;
  43.   int matover;
  44.   int ninc;
  45.  
  46.     flag = _mgc->astk->ap.flag;
  47.     shading = _mgc->astk->ap.shading;
  48.     matover = _mgc->astk->mat.override;
  49.     ninc = (nn > 1);
  50.     if ((matover & MTF_DIFFUSE) && !_mgc->astk->useshader) nc = 0;
  51.     
  52.     mrti(mr_polygon,mr_NULL);
  53.     
  54.     /* Points */
  55.     if(nv>0 && (flag & APF_FACEDRAW)) {
  56.     mrti(mr_P,mr_buildarray, nv*3, mr_NULL);
  57.     for(i = 0; i < nv; i++) {
  58.         /* we cannot descibe a polygon using Pw, so we normalize */
  59.         HPt3Normalize(&V[i], &hpt);
  60.         mrti(mr_subarray3, &hpt, mr_NULL);
  61.     }
  62.     }
  63.  
  64.     /* Supply Color (explicit) */
  65.     if (nc>0 && (flag & APF_FACEDRAW) && !(flag & APF_CONSTANT)) {
  66.     /* note:color should already be set in case of APF_CONSTANT,no?  */
  67.     mrti(mr_Cs, mr_buildarray, nv*3, mr_NULL);
  68.     for(i = 0; i < nv; i++) {
  69.         if(nc>1) c4 = &C[i]; else c4 = C;
  70.         mrti(mr_subarray3, (float *)c4, mr_NULL);
  71.     }
  72.     }
  73.  
  74.     /* Supply Transparency */
  75.     if(nc>0 && flag & APF_TRANSP && !(matover & MTF_ALPHA)) {
  76.     mrti(mr_Os, mr_buildarray, nv*3, mr_NULL);
  77.     for(i = 0; i < nv; i++) {
  78.         float opacity[3];
  79.         if(nc>1) c4 = &C[i]; else c4 = C;
  80.         opacity[0]=opacity[1]=opacity[2]=c4->a;
  81.         mrti(mr_subarray3, opacity, mr_NULL);
  82.     }
  83.     }
  84.     /* Supply Normals */
  85.     if (nn>0 && (flag & APF_FACEDRAW) && !(flag & APF_CONSTANT)) {
  86.     mrti(mr_N, mr_buildarray, nv*3, mr_NULL); 
  87.     for(i = 0; i < nv; i++) {
  88.         if(nn>1) n = &N[i]; else n = N;
  89.         mrti(mr_subarray3, n, mr_NULL);
  90.     }
  91.     }
  92.     
  93.     /* Draw Edges */
  94.     if(flag & APF_EDGEDRAW) {
  95.     c = &_mgc->astk->ap.mat->edgecolor;
  96.     mrti(mr_attributebegin,
  97.         mr_surface, mr_constant, 
  98.         mr_color, mr_parray, 3, c,
  99.         mr_opacity, mr_array, 3, 1., 1., 1., mr_NULL);
  100.     
  101.     for(i=0;i<nv-1;i++) mgrib_drawline(&V[i],&V[i+1]);
  102.     mgrib_drawline(&V[i],&V[0]);
  103.     mrti(mr_attributeend, mr_NULL);
  104.     }
  105.     
  106.     /* Draw Normals */
  107.     if(flag & APF_NORMALDRAW) {
  108.     for (n = N, v = V, i = 0; i<nv; ++i, ++v, n += ninc)
  109.     mgrib_drawnormal(v, n);
  110.     }
  111. }
  112.  
  113. /*-----------------------------------------------------------------------
  114.  * Function:    mgrib_line
  115.  * Description:    draws a line
  116.  * Author:    wisdom
  117.  * Date:    Fri Jan 17 14:31:06 CST 1992
  118.  * Notes:    see mg.doc
  119.  */
  120. void mgrib_line( HPoint3 *p1, HPoint3 *p2 )
  121. {
  122.     mrti(mr_attributebegin, mr_surface, mr_constant, mr_NULL);
  123.     mgrib_drawline(p1,p2);
  124.     mrti(mr_attributeend, mr_NULL);
  125. }
  126.  
  127. /*-----------------------------------------------------------------------
  128.  * Function:    mgrib_drawline, mgrib_drawPline, mgrib_drawCline, bounded
  129.  * Description: draws a line for rman.
  130.  * Returns:    nothing
  131.  * Author:    wisdom, gunn, slevy, munzner
  132.  * Date:    Tue Feb 18 14:20:29 CST 1992
  133.  * Notes:
  134.  */
  135. void
  136. mgrib_drawline(HPoint3 *p1, HPoint3 *p2)
  137. {
  138.     if(_mgribc->line_mode==MG_RIBPOLYGON) mgrib_drawPline(p1,p2);
  139.     if(_mgribc->line_mode==MG_RIBCYLINDER) mgrib_drawCline(p1,p2);
  140.     if(_mgribc->line_mode==MG_RIBPRMANLINE)
  141.         NotImplemented("MG_RIBPRMANLINE");
  142. }
  143.  
  144. void
  145. mgrib_drawPline(HPoint3 *p1, HPoint3 *p2)
  146. {
  147.     Transform V;
  148.     Transform P2S,O2S, O2P, P2O, S2O;
  149.     int xsize, ysize;
  150.     HPoint3 pnts[4], pnts2[4];
  151.     HPoint3 s1, s2;
  152.     int i;
  153.     float dx,dy,k, len;
  154.  
  155.     /* This code will simulate line drawing in Photorman */
  156.     /* create obj->proj transform */
  157.     CamView(_mgc->cam, V);        /* world->proj */
  158.     TmConcat(_mgc->xstk->T, V, O2P);    /* obj->proj */
  159.     
  160.     /* create obj->screen transform */
  161.     WnGet(_mgc->win, WN_XSIZE, &xsize);
  162.     WnGet(_mgc->win, WN_YSIZE, &ysize);
  163.     TmScale(P2S, (float)xsize, (float)ysize, 1.0);
  164.     TmConcat(O2P, P2S, O2S);
  165.     
  166.     /* translate & dehomogenize line endpoints from object to screen */
  167.     HPt3TransPt3(O2S, p1, &s1);
  168.     HPt3TransPt3(O2S, p2, &s2);
  169.  
  170.     dy = s2.y - s1.y;
  171.     dx = s2.x - s1.x;
  172.     len = hypot(dy,dx);
  173.     k = _mgc->astk->ap.linewidth / len;
  174.     
  175.     pnts[0].x = s1.x -dy * k;
  176.     pnts[0].y = s1.y +dx * k;
  177.     pnts[1].x = s1.x +dy * k;
  178.     pnts[1].y = s1.y -dx * k;
  179.     pnts[2].x = s2.x +dy * k;
  180.     pnts[2].y = s2.y -dx * k;
  181.     pnts[3].x = s2.x -dy * k;
  182.     pnts[3].y = s2.y +dx * k;
  183.         
  184.     pnts[0].z = s1.z;
  185.     pnts[1].z = s1.z;
  186.     pnts[2].z = s2.z;
  187.     pnts[3].z = s2.z;
  188.     
  189.     for (i=0; i<4; ++i) pnts[i].w = 1.0;
  190.          
  191.     /* now project back... */
  192.     /* first, find S2O transform */
  193.     TmInvert(O2S, S2O);
  194.     
  195.     /* now transform screen coords to object coords */
  196.     
  197.     /* DRAW HERE */
  198.     mrti(mr_polygon, mr_P, mr_buildarray, 4*3, mr_NULL);
  199.     for(i=0;i<4;i++) {
  200.     HPoint3 pt;
  201.  
  202.     HPt3Transform(S2O, &pnts[i], &pt);
  203.     HPt3Normalize(&pt, &pt);
  204.     mrti(mr_subarray3, &pt, mr_NULL);
  205.     }
  206. }
  207.  
  208. void
  209. mgrib_drawCline(HPoint3 *p1, HPoint3 *p2)
  210. {
  211.   Pt3Coord angle,length;
  212.   Point3 t,xn,yn,axis;
  213.   Point3 start, end;
  214.   HPoint3 Hstart, Hend;
  215.   static float unitz[3] = {0.0, 0.0, 1.0};
  216.   float radius = .005;
  217.   float size;
  218.   int bounded(Point3 *p);
  219.   
  220.     HPt3Normalize(p1, &Hstart);
  221.     HPt3Normalize(p2, &Hend);
  222.     
  223.     start.x = Hstart.x;
  224.     start.y = Hstart.y;
  225.     start.z = Hstart.z;
  226.     
  227.     end.x = Hend.x;
  228.     end.y = Hend.y;
  229.     end.z = Hend.z;
  230.     
  231.     if (! Pt3Equal(&start,&end)) {
  232.     size = radius*_mgc->astk->ap.linewidth;
  233.     Pt3Sub(&end,&start,&t);
  234.     length = Pt3Length(&t);
  235.     Pt3Cross((Point3*)unitz,&t,&axis);
  236.     Pt3Unit(&t);
  237.     angle = Pt3Dot((Point3*)unitz,&t);
  238.     angle = acos(angle);
  239.     mrti(mr_transformbegin, mr_NULL);
  240.     if (bounded(&start))
  241.         mrti(mr_translate,
  242.             mr_float, start.x,
  243.         mr_float, start.y,
  244.         mr_float, start.z, mr_NULL);
  245.     if ( (t.x == 0.0) && (t.y == 0.0) && (t.z < 0.0)) {
  246.         /* if along negative z axis cross product is 0
  247.         but rotation by 180 degrees is necessary
  248.         (angle is computed correctly) */
  249.         axis.y = 1.0;
  250.     }
  251.     if (bounded(&axis))
  252.         mrti(mr_rotate, mr_float, DEGREES(angle),
  253.             mr_float, axis.x, mr_float, axis.y, mr_float, axis.z, mr_NULL);
  254.     if (length < MAXCLINE)
  255.         mrti(mr_cylinder, mr_float, size, mr_float, 0.,
  256.             mr_float, length, mr_float, 360., mr_NULL);
  257.     mrti(mr_transformend, mr_NULL);
  258.     }
  259. }
  260.  
  261. int 
  262. bounded(p)
  263. Point3 *p;
  264. {
  265.   if (! Pt3Equal(p,&Pt3Origin)) {
  266.     if (p->x < MAXCLINE && p->y < MAXCLINE && p->z < MAXCLINE) 
  267.       return 1;
  268.   } else {
  269.     return 0;
  270.   }
  271. }
  272.  
  273.  
  274.  
  275. /*-----------------------------------------------------------------------
  276.  * Function:    mgrib_polyline
  277.  * Description:    draws a Polyline
  278.  * Author:    wisdom
  279.  * Date:    Fri Jan 17 14:31:06 CST 1992
  280.  * Notes:    see mg.doc
  281.  */
  282. void mgrib_polyline( int nv, HPoint3 *v, int nc, ColorA *c, int wrapped )
  283. {
  284.     ColorA *color;
  285.     
  286.     mrti(mr_attributebegin, mr_surface, mr_constant, mr_NULL);
  287.     if(nc==0) mrti(mr_color, mr_parray, 3,
  288.         &_mgc->astk->mat.edgecolor, mr_NULL);
  289.     if(nc==1) mrti(mr_color, mr_parray, 3, c, mr_NULL);
  290.     if(nv == 1) {
  291.         mgrib_drawpoint(v);
  292.     }
  293.     else {
  294.         if(wrapped & 1) {
  295.         if(nc > 1) {
  296.             color = c + nc - 1;
  297.             mrti(mr_color, mr_parray, 3, color, mr_NULL);
  298.         }
  299.         mgrib_drawline(v + nv - 1,v);
  300.         }
  301.     
  302.         while(--nv > 0) {
  303.         if(nc > 1) {
  304.             color = c++;
  305.             mrti(mr_color, mr_parray, 3, color, mr_NULL);
  306.         }
  307.         mgrib_drawline(v,(v+1));
  308.         v++;
  309.         }
  310.     }
  311.     
  312.     mrti(mr_attributeend, mr_NULL);
  313.  
  314. }
  315.  
  316. /*-----------------------------------------------------------------------
  317.  * Function:    mgrib_drawpoint
  318.  * Description: draws a point for rman.
  319.  * Returns:    nothing
  320.  * Author:    wisdom
  321.  * Date:    Fri Mar 13 15:04:01 CST 1992    
  322.  * Notes:
  323.  */
  324.  
  325. void
  326. mgrib_drawpoint(HPoint3 *p)
  327. {
  328.     float radius = 0.005;
  329.     float size = radius*_mgc->astk->ap.linewidth;
  330.     
  331.     mrti(mr_transformbegin, mr_NULL);
  332.     mrti(mr_translate, mr_float, p->x, mr_float, p->y, 
  333.      mr_float, p->z, mr_NULL);
  334.     mrti(mr_sphere, mr_float, size, mr_float, size, mr_float, -size,
  335.     mr_float, 360., mr_NULL);
  336.     mrti(mr_transformend, mr_NULL);
  337. }
  338.  
  339. /*-----------------------------------------------------------------------
  340.  * Function:    mgrib_polylist
  341.  * Description:    draws a Polylist: linked list of Polys
  342.  * Author:    wisdom
  343.  * Date:    Wed Jan 22 16:07:03 CST 1992
  344.  * Notes:    see mg.doc
  345.  */
  346. void mgrib_polylist( int np, Poly *P, int nv, Vertex *V, int plflags )
  347. {
  348.   register int i,j;
  349.   register Poly *p;
  350.   register Vertex **v, *vp;
  351.   register Point3 *n;
  352.   HPoint3 hpt;
  353.   int flag,shading,matover;
  354.   Color *color;
  355.   ColorA *colorA;
  356.   
  357.   
  358.   flag = _mgc->astk->ap.flag;
  359.   shading = _mgc->astk->ap.shading;
  360.   matover = _mgc->astk->mat.override;
  361.  
  362.   if((matover & MTF_DIFFUSE) && !_mgc->astk->useshader)
  363.     plflags &= ~(PL_HASVCOL | PL_HASPCOL);
  364.   
  365.   if (shading & APF_CONSTANT) plflags &= ~(PL_HASVN|PL_HASPN);
  366.   else if (shading & APF_FLAT) plflags &= ~PL_HASVN;
  367.   else if (shading & APF_SMOOTH) plflags &= ~PL_HASPN;
  368.  
  369.   if (flag & APF_FACEDRAW) {
  370.     mrti(mr_attributebegin, mr_NULL);
  371.     for (p = P, i = 0; i < np; i++, p++) {
  372.       
  373.       /* per polygon color */
  374.       if (plflags & PL_HASPCOL) {
  375.     mrti(mr_color, mr_parray, 3, &p->pcol, mr_NULL);
  376.     /* then per-polygon transparency, if defined */
  377.     if (flag & APF_TRANSP && !(matover & MTF_ALPHA)) {
  378.       mrti(mr_Os, mr_array, 3, 
  379.            p->pcol.a, p->pcol.a, p->pcol.a, mr_NULL);
  380.     }
  381.       }
  382.       switch (p->n_vertices) {
  383.       case 1:
  384.     v = p->v;
  385.     mrti(mr_attributebegin, mr_NULL);
  386.     if(plflags & PL_HASVCOL) 
  387.       mrti(mr_color, mr_parray, 3, &(*v)->vcol, mr_NULL);          
  388.     mrti(mr_surface, mr_constant,
  389.          mr_opacity, mr_array, 3, 1., 1., 1., mr_NULL);
  390.     mgrib_drawpoint((HPoint3 *)(*v));
  391.     mrti(mr_attributeend, mr_NULL);
  392.     break;
  393.       case 2:
  394.     v = p->v;
  395.     mrti(mr_attributebegin, mr_NULL);
  396.     if(plflags & PL_HASVCOL)
  397.       mrti(mr_color, mr_parray, 3, &(*v)->vcol, mr_NULL);          
  398.     mrti(mr_surface, mr_constant,
  399.          mr_opacity, mr_array, 3, 1., 1., 1., mr_NULL);
  400.     mgrib_drawline((HPoint3 *)*v,(HPoint3*)*(v+1));
  401.     mrti(mr_attributeend, mr_NULL);
  402.     break;
  403.       default:
  404.     mrti(mr_polygon, mr_NULL);
  405.     
  406.     /* do points */
  407.     mrti(mr_P, mr_buildarray, p->n_vertices*3, mr_NULL);
  408.     for (j=0, v=p->v; j < p->n_vertices; j++, v++) {
  409.       HPt3Normalize(&(*v)->pt, &hpt);
  410.       mrti(mr_subarray3, &hpt, mr_NULL);
  411.     }
  412.     
  413.     /* colors, if supplied */
  414.     if(plflags & PL_HASVCOL) {
  415.       mrti(mr_Cs, mr_buildarray, p->n_vertices*3, mr_NULL);
  416.       for (j=0, v=p->v; j < p->n_vertices; j++, v++) {
  417.         mrti(mr_subarray3, &(*v)->vcol, mr_NULL);
  418.       }
  419.       /* then per-vertex transparency, if defined */
  420.       if(flag & APF_TRANSP && !(matover & MTF_ALPHA)) {
  421.         mrti(mr_Os, mr_buildarray, p->n_vertices*3, mr_NULL);
  422.         for (j=0, v=p->v; j < p->n_vertices; j++, v++) {
  423.           float opacity[3];
  424.           opacity[0]=opacity[1]=opacity[2]=(*v)->vcol.a;
  425.           mrti(mr_subarray3, opacity, mr_NULL);
  426.         }
  427.       }
  428.     }
  429.     
  430.     /* now normals, if supplied */
  431.     if(plflags & PL_HASVN) {
  432.       mrti(mr_N, mr_buildarray, p->n_vertices*3, mr_NULL);
  433.       for (j=0, v=p->v; j < p->n_vertices; j++, v++) {
  434.         mrti(mr_subarray3, &((*v)->vn), mr_NULL);
  435.       }
  436.     } else if(plflags & PL_HASPN) {
  437.       mrti(mr_N, mr_buildarray, p->n_vertices*3, mr_NULL);
  438.       for(j=0, v=p->v; j< p->n_vertices; j++, v++) {
  439.         mrti(mr_subarray3, &(p->pn), mr_NULL);
  440.       }
  441.     }
  442.     break;
  443.       }
  444.     }
  445.     mrti(mr_attributeend, mr_NULL);
  446.   }    
  447.   if (flag & APF_EDGEDRAW) {
  448.     color = &_mgc->astk->ap.mat->edgecolor;
  449.     mrti(mr_attributebegin, mr_surface, mr_constant,
  450.      mr_color, mr_parray, 3, color,
  451.      mr_opacity, mr_array, 3, 1., 1., 1., mr_NULL);
  452.     
  453.     for (p = P, i = 0; i < np; i++, p++) {    
  454.       for (j=0, v=p->v; j < (p->n_vertices-1); j++, v++) {
  455.     mgrib_drawline((HPoint3 *)*v,(HPoint3*)*(v+1));
  456.       }
  457.       mgrib_drawline((HPoint3 *)*v,(HPoint3 *)*(p->v));
  458.     }
  459.     mrti(mr_attributeend,mr_NULL);
  460.   }
  461.   
  462.   
  463.   if (flag & APF_NORMALDRAW) {
  464.     /* since mg_drawnormal handles attributes and stacking, we do nothing here */
  465.     if (plflags & PL_HASPN) {
  466.       for (p = P, i = 0; i < np; i++, p++) {
  467.     for (j=0, v=p->v; j < p->n_vertices; j++, v++) {
  468.       mgrib_drawnormal(&(*v)->pt, &p->pn);
  469.     }
  470.       }
  471.     } else if (plflags & PL_HASVN) {
  472.       for (vp = V, i = 0; i < nv; i++, vp++) {
  473.     mgrib_drawnormal(&vp->pt, &vp->vn);
  474.       }
  475.     }
  476.   }
  477.   
  478. }
  479.  
  480. /* There is a basic problem now with 4-d points and 3-d normal vectors.
  481. For now, we'll just ignore the 4-th coordinate of the point when 
  482. computing the tip of the normal vector.  This will work OK with all
  483. existing models, but for genuine 4-d points it won't work.  But,
  484. come to think of it, what is the correct interpretation of the
  485. normal vector when the points live in 4-d?
  486. */
  487. void
  488. mgrib_drawnormal(HPoint3 *p, Point3 *n) {    
  489.     HPoint3 end, tp;
  490.     float scale;
  491.     Color *color;
  492.     
  493.     if (p->w <= 0.0) return;
  494.     scale = p->w * _mgc->astk->ap.nscale;
  495.     end.x = p->x + scale*n->x;
  496.     end.y = p->y + scale*n->y;
  497.     end.z = p->z + scale*n->z;
  498.     end.w = p->w;
  499.  
  500.     color = &_mgc->astk->mat.normalcolor;
  501.     mrti(mr_attributebegin, mr_surface, mr_constant,
  502.      mr_color, mr_parray, 3, color,
  503.      mr_opacity, mr_array, 3, 1., 1., 1., mr_NULL);
  504.     mgrib_drawline(&tp,&end);
  505.     mrti(mr_attributeend, mr_NULL);
  506.     
  507. }
  508.  
  509. void
  510. mgrib_bezier( int du, int dv, int dimn, float *CtrlPnts, float *txmapst, ColorA *c )
  511. {
  512.     int i, ip, nu, nv;
  513.     static float *uknot=NULL, *vknot=NULL;
  514.     static size_t ulen=0,vlen=0;
  515.     size_t nulen=0, nvlen=0;
  516.     int  flag = _mgc->astk->ap.flag;
  517.     int  matover = _mgc->astk->mat.override;
  518.  
  519.     du += 1;
  520.     dv += 1;
  521.     nu = du;
  522.     nv = dv;
  523.     ip = nu * nv * dimn; 
  524.  
  525.     if(!uknot) {
  526.         ulen=nu+du;
  527.     uknot=(float *)malloc(ulen*sizeof(float));
  528.     }
  529.     if(!vknot) {
  530.         vlen=nv+dv;
  531.     vknot=(float *)malloc(vlen*sizeof(float));
  532.     }
  533.     nulen=nu+du;
  534.     nvlen=nv+dv;
  535.     if(nulen>ulen) uknot=(float *)realloc(uknot,(ulen=nulen)*sizeof(float));
  536.     if(nvlen>vlen) vknot=(float *)realloc(vknot,(vlen=nvlen)*sizeof(float));
  537.     
  538.     /* uknot = (float *)malloc((nu+du)*sizeof(float)); */
  539.     for(i=0;i<nu;i++) uknot[i] = 0;
  540.     for(i=nu;i<(nu+du);i++) uknot[i] = 1;
  541.     
  542.     /* vknot = (float *)malloc((nv+dv)*sizeof(float)); */
  543.     for(i=0;i<nv;i++) vknot[i] = 0;
  544.     for(i=nv;i<(nv+dv);i++) vknot[i] = 1;
  545.  
  546.     mrti(mr_nupatch, mr_int, nu, mr_int, du, mr_NULL);
  547.     mrti(mr_parray, (nu+du), uknot, mr_NULL);
  548.     mrti(mr_int, 0, mr_int, (nu-1), mr_int, nv, mr_int, dv, mr_NULL);
  549.     mrti(mr_parray, (nv+dv), vknot, mr_NULL);
  550.     mrti(mr_int, 0, mr_int, nv -1, mr_NULL);
  551.     
  552.     mrti(dimn == 3 ? mr_P : mr_Pw,
  553.     mr_parray, ip, CtrlPnts, mr_NULL);
  554.     
  555.     /* free(uknot); */
  556.     /* free(vknot); */
  557.     
  558.     if(c && !( (matover & MTF_DIFFUSE) && !_mgc->astk->useshader) ) {
  559.         mrti(mr_Cs, mr_buildarray,  12, mr_NULL);
  560.     for (i = 0; i < 4; i++) {
  561.         mrti(mr_subarray3, (float *)&c[i], mr_NULL);
  562.     }
  563.     if(flag & APF_TRANSP && !(matover & MTF_ALPHA)) {
  564.         float opacity[3];
  565.         opacity[0]=opacity[1]=opacity[2]=c[i].a;
  566.         mrti(mr_Os, mr_buildarray, 12, mr_NULL);
  567.         for (i = 0; i < 4; i++) {
  568.             mrti(mr_subarray3, opacity, mr_NULL);
  569.         }
  570.     }
  571.     }
  572.     
  573.     if(txmapst) {
  574.         mrti(mr_nl, mr_st, mr_parray, 8, txmapst, mr_NULL);
  575.     }
  576. }
  577.